`:top
`!PascalABC.NET`! is a `F33f`_`[high-level`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=High-level_programming_language]`_`f `F33f`_`[general-purpose`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=General-purpose_programming_language]`_`f `F33f`_`[programming language`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Programming_language]`_`f supporting multiple paradigms. PascalABC.NET is based on `F33f`_`[Delphi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Delphi_(software)]`_`f's `F33f`_`[Object Pascal`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Object_Pascal]`_`f, but also has influences from `F33f`_`[C#`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=C_Sharp_(programming_language)]`_`f, `F33f`_`[Python`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Python_(programming_language)]`_`f, `F33f`_`[Kotlin`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Kotlin_(programming_language)]`_`f, and `F33f`_`[Haskell`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Haskell]`_`f. It is distributed both as a command-line tool for Windows (`F33f`_`[.NET`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=.NET]`_`f framework), Linux and MacOS (Mono), and with an `F33f`_`[integrated development environment`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Integrated_development_environment]`_`f for Windows and Linux, including interactive debugger, `F33f`_`[IntelliSense`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Intelligent_code_completion]`_`f system, `F33f`_`[form designer`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Graphical_user_interface_builder]`_`f, code templates and code auto-formatting.
PascalABC.NET is implemented for the `F33f`_`[.NET`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=.NET]`_`f framework platform, so that it is compatible with all .NET libraries and utilizes all the features of `F33f`_`[Common Language Runtime`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Common_Language_Runtime]`_`f, such as `F33f`_`[garbage collection`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Garbage_collection_(computer_science)]`_`f, `F33f`_`[exception handling`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Exception_handling]`_`f, and `F33f`_`[generics`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Generic_programming]`_`f. Some language constructions, e.g. tuples, sequences, and lambdas, are based on regular .NET types. PascalABC.NET is ideologically close to `F33f`_`[Oxygene`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Oxygene_(programming_language)]`_`f, but unlike it, provides high compatibility with `F33f`_`[Delphi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Delphi_(software)]`_`f.
>>Contents
• `F0af`_`[History of PascalABC.NET`#history-of-pascalabc-net]`_`f
• `F0af`_`[Use in school and higher education`#use-in-school-and-higher-education]`_`f
• `F0af`_`[Language syntax`#language-syntax]`_`f
• `F0af`_`[Differences between Delphi and PascalABC.NET`#differences-between-delphi-and-pascalabc-net]`_`f
• `F0af`_`[Functional style features`#functional-style-features]`_`f
• `F0af`_`[Code examples`#code-examples]`_`f
• `F0af`_`[Usual PascalABC.NET style`#usual-pascalabc-net-style]`_`f
• `F0af`_`[Procedural style`#procedural-style]`_`f
• `F0af`_`[Functional style`#functional-style]`_`f
• `F0af`_`[Object-oriented style`#object-oriented-style]`_`f
• `F0af`_`[Close to regular C# style`#close-to-regular-c-style]`_`f
• `F0af`_`[Criticism`#criticism]`_`f
• `F0af`_`[References`#references]`_`f
• `F0af`_`[External links`#external-links]`_`f
-─
>>History of PascalABC.NET
PascalABC.NET was developed by a group of enthusiasts at the Institute of Mathematics, Mechanics, and Computer Science in Rostov-on-Don, Russia.`:cite-ref-1-1-0[`F5bf`_`[1`#cite-note-1-1]`_`f] In 2003, a predecessor of the modern PascalABC.NET, called Pascal ABC, was implemented by associate professor Stanislav Mikhalkovich to be used for teaching schoolchildren instead of `F33f`_`[Turbo Pascal`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Turbo_Pascal]`_`f, which became outdated and incompatible with modern operating systems but was still used for educational purposes. Pascal ABC was implemented as an `F33f`_`[interpreted programming language`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Interpreter_(computing)]`_`f, that led to a significant lack of performance. Four years after that it was completely rewritten by students Ivan Bondarev, Alexander Tkachuk, and Sergey Ivanov as a `F33f`_`[compiled programming language`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Compiled_language]`_`f for the .NET platform. In 2009, PascalABC.NET started to be actively used for teaching high school students. By 2015, the number of users of the language had increased significantly. It began to be actively used throughout Russia in schools and at programming contests, surpassing `F33f`_`[Free Pascal`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Free_Pascal]`_`f. Since then, the PascalABC.NET developers have set themselves the goal of actively incorporating modern features into the language. In the same year, PascalABC.NET became an open source project distributed under the `F33f`_`[GNU Lesser General Public License`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=GNU_Lesser_General_Public_License]`_`f (LGPLv3).`:cite-ref-2[`F5bf`_`[2`#cite-note-2]`_`f]`:cite-ref-3[`F5bf`_`[3`#cite-note-3]`_`f]
In 2017`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f] and 2022,`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f] independent audit of PascalABC.NET public repository was conducted. Based on the results of the static check, potentially dangerous code fragments were listed that require additional analysis by developers. It was also noted that the overall quality of the code could be improved. To do this, code duplication and redundant checks should be eliminated, and refactoring should be performed more carefully.
>>Use in school and higher education
Designed for education, PascalABC.NET remains the most common programming language in Russian schools and one of the recommended languages for passing the `F33f`_`[Unified State Exam`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Unified_State_Exam]`_`f on informatics.`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f]`:cite-ref-4-7-0[`F5bf`_`[7`#cite-note-4-7]`_`f]`:cite-ref-3-8-0[`F5bf`_`[8`#cite-note-3-8]`_`f] In the Southern Federal University, it is used as the first language for teaching students majoring in computer science, and for teaching children in one of the largest computer schools in Russia.`:cite-ref-9[`F5bf`_`[9`#cite-note-9]`_`f] PascalABC.NET is widely used as a basic programming language in pedagogical universities for the training of computer science teachers.`:cite-ref-mathanim-10-0[`F5bf`_`[10`#cite-note-mathanim-10]`_`f]`:cite-ref-hammingcode-11-0[`F5bf`_`[11`#cite-note-hammingcode-11]`_`f]`:cite-ref-scigraph-12-0[`F5bf`_`[12`#cite-note-scigraph-12]`_`f]`:cite-ref-13[`F5bf`_`[13`#cite-note-13]`_`f] It also serves as a tool for scientific computing.`:cite-ref-14[`F5bf`_`[14`#cite-note-14]`_`f]`:cite-ref-15[`F5bf`_`[15`#cite-note-15]`_`f] PascalABC.NET is also built into a number of validation systems used for programming competitions.`:cite-ref-16[`F5bf`_`[16`#cite-note-16]`_`f]`:cite-ref-17[`F5bf`_`[17`#cite-note-17]`_`f]
In 2020, during anti-COVID lockdowns and home schooling period, PascalABC.NET website was ranked 3rd in Yandex traffic rating in the "Programming" category, and the number of downloads of the installation kit exceeded 10000 a day.`:cite-ref-18[`F5bf`_`[18`#cite-note-18]`_`f]
Though the core of the PascalABC.NET community is located in Russia, the language is also known in other countries such as Belarus,`:cite-ref-19[`F5bf`_`[19`#cite-note-19]`_`f] Romania,`:cite-ref-20[`F5bf`_`[20`#cite-note-20]`_`f] Indonesia,`:cite-ref-21[`F5bf`_`[21`#cite-note-21]`_`f] Algeria.`:cite-ref-22[`F5bf`_`[22`#cite-note-22]`_`f]
>>Language syntax
>>>Differences between Delphi and PascalABC.NET
>>>>New features
`!•`! `B100`F9d9loop`f`b statement
`B100`F9d9loop 10 do`f`b
`B100`F9d9 Write('*');`f`b
`!•`! `B100`F9d9for`f`b loop with a step
`B100`F9d9for var i:=1 to 20 step 2 do`f`b
`B100`F9d9 Print(i);`f`b
`!•`! `B100`F9d9foreach`f`b loop with an index
`B100`F9d9foreach var c in Arr('a'..'z') index i do`f`b
`B100`F9d9 if i mod 2 = 0 then`f`b
`B100`F9d9 Print(c);`f`b
`!•`! `B100`F9d9a..b`f`b ranges
`B100`F9d9(1..10).Printlines`f`b
`!•`! short function definition syntax
`B100`F9d9function Sum(a,b: real) := a + b;`f`b
`!•`! method implementation can be placed inside a class definition
`B100`F9d9type Point = class`f`b
`B100`F9d9 x,y: real;`f`b
`B100`F9d9 procedure Output;`f`b
`B100`F9d9 begin`f`b
`B100`F9d9 Print(x,y);`f`b
`B100`F9d9 end;`f`b
`B100`F9d9end;`f`b
`!•`! `B100`F9d9sequence of T`f`b type as an abstraction of arrays, lists and sets
`B100`F9d9var seq: sequence of integer := Arr(1..10);`f`b
`B100`F9d9seq.Println;`f`b
`B100`F9d9seq := Lst(11..100); seq.Println;`f`b
`B100`F9d9seq := HSet(1..20); seq.Println;`f`b
`!•`! `F33f`_`[lambda functions`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Anonymous_function]`_`f
`B100`F9d9var a := ArrGen(10,i -> i*i);`f`b
`!•`! auto classes - classes with an automatically generated constructor
`B100`F9d9type Point = auto class`f`b
`B100`F9d9 x,y: real;`f`b
`B100`F9d9end;`f`b
`B100`F9d9var p := new Point(2,5);`f`b
`!•`! one-dimensional and multi-dimensional array slices
`B100`F9d9var m: array [,] of integer := MatrGen(3,4, (i,j) -> i+j+1);`f`b
`B100`F9d9Println(m); // [[1,2,3,4],[2,3,4,5],[3,4,5,6]]`f`b
`B100`F9d9Println(m[:2,1:3]); // [[2,3],[3,4]]`f`b
Some other features such as inline variable declarations, type inference, and `B100`F9d9for`f`b statement with a variable declaration are standard in the current version of Delphi. However, PascalABC.NET pioneered these features in 2007,`:cite-ref-2-23-0[`F5bf`_`[23`#cite-note-2-23]`_`f] while in Delphi they were implemented in 2018.`:cite-ref-24[`F5bf`_`[24`#cite-note-24]`_`f]`:cite-ref-25[`F5bf`_`[25`#cite-note-25]`_`f]
>>>>Changed features
• strings in `B100`F9d9case`f`b statements
• sets based on arbitrary type: `B100`F9d9set of string`f`b
• constructors can be invoked with `B100`F9d9new T(...)`f`b syntax
• type extension methods instead of class helpers
• modules can be defined in a simplified form (without `B100`F9d9interface`f`b and `B100`F9d9implementation`f`b sections)
>>>>Not implemented features
• records with variant parts
• open arrays
• nested class definitions
• `F33f`_`[inline assembly code`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Inline_assembler]`_`f
>>>Functional style features
In PascalABC.NET, functions are `F33f`_`[first-class objects`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=First-class_citizen]`_`f. They can be assigned to variables, passed as parameters, and returned from other functions. Functional type is set in the form `B100`F9d9T -> Res`f`b.`:cite-ref-26[`F5bf`_`[26`#cite-note-26]`_`f] An `F33f`_`[anonymous function`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Anonymous_function]`_`f can be assigned to the variable of this type:
`B100`F9d9## // denotes that the main program will be written without enclosing begin-end`f`b
`B100`F9d9var f: real -> real := x -> x*x;`f`b
Here is an example of `F33f`_`[superposition`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Function_composition_(computer_science)]`_`f of two functions:
`B100`F9d9##`f`b
`B100`F9d9function Super<T,T1,T2>(f: T1 -> T2; g: T -> T1): T -> T2 := x -> f(g(x));`f`b
`B100`F9d9`f`b
`B100`F9d9var f: real -> real := x -> x*x;`f`b
`B100`F9d9var fg := Super(f,Sin);`f`b
`B100`F9d9var gf := Super(Sin,f);`f`b
`B100`F9d9`f`b
`B100`F9d9Print(fg(2));`f`b
`B100`F9d9Print(gf(2));`f`b
Superposition operation is defined in the standard library:
`B100`F9d9##`f`b
`B100`F9d9var f: real -> real := x -> x*x;`f`b
`B100`F9d9`f`b
`B100`F9d9Print((f*Cos)(2));`f`b
`B100`F9d9Print((Cos*f)(2));`f`b
In the book "How To Program Effectively In Delphi"`:cite-ref-27[`F5bf`_`[27`#cite-note-27]`_`f] and in the corresponding video tutorials,`:cite-ref-0-28-0[`F5bf`_`[28`#cite-note-0-28]`_`f]`:cite-ref-29[`F5bf`_`[29`#cite-note-29]`_`f] Dr. Kevin Bond, a programmer and a Computer Science teaching specialist,`:cite-ref-30[`F5bf`_`[30`#cite-note-30]`_`f] notes that PascalABC.NET has powerful functional programming capabilities which are missing in Delphi. As an example, `F33f`_`[partial function application`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Partial_application]`_`f is demonstrated:
`B100`F9d9begin`f`b
`B100`F9d9 var f: integer -> integer -> integer := x -> y -> x + y;`f`b
`B100`F9d9 Writeln(f(2)(6));`f`b
`B100`F9d9end.`f`b
>>Code examples
PascalABC.NET is a multi-paradigm programming language. It allows one to use different coding styles from oldschool Pascal to functional and object-oriented programming. The same task can be solved in different styles as follows:`:cite-ref-31[`F5bf`_`[31`#cite-note-31]`_`f]
>>>Usual PascalABC.NET style
`B100`F9d9begin`f`b
`B100`F9d9 var (a,b) := ReadInteger2; // read input into tuple of two variables`f`b
`B100`F9d9 var sum := 0; // type auto-inference`f`b
`B100`F9d9 for var i:=a to b do`f`b
`B100`F9d9 sum += i*i;`f`b
`B100`F9d9 Print($'Sum = {sum}') // string interpolation`f`b
`B100`F9d9end.`f`b
>>>Procedural style
`B100`F9d9function SumSquares(a,b: integer): integer;`f`b
`B100`F9d9begin`f`b
`B100`F9d9 Result := 0;`f`b
`B100`F9d9 for var i := a to b do`f`b
`B100`F9d9 Result += i * i`f`b
`B100`F9d9end;`f`b
`B100`F9d9`f`b
`B100`F9d9begin`f`b
`B100`F9d9 var (a,b) := ReadInteger2;`f`b
`B100`F9d9 Print($'Sum = {SumSquares(a,b)}')`f`b
`B100`F9d9end.`f`b
>>>Functional style
This solution uses .NET extension methods for sequences and PascalABC.NET-specific range `B100`F9d9(a..b)`f`b.
`B100`F9d9begin`f`b
`B100`F9d9 var (a,b) := ReadInteger2;`f`b
`B100`F9d9 (a..b).Sum(x -> x*x).Print // method chaining with lambda expressions`f`b
`B100`F9d9end.`f`b
>>>Object-oriented style
This solution demonstrates PascalABC.NET-specific short function definition style.
`B100`F9d9type Algorithms = class`f`b
`B100`F9d9 static function SumSquares(a,b: integer) := (a..b).Sum(x -> x*x);`f`b
`B100`F9d9 static function SumCubes(a,b: integer) := (a..b).Sum(x -> x*x*x);`f`b
`B100`F9d9end;`f`b
`B100`F9d9`f`b
`B100`F9d9begin`f`b
`B100`F9d9 var (a,b) := ReadInteger2;`f`b
`B100`F9d9 Println($'Squares sum = {Algorithms.SumSquares(a,b)}');`f`b
`B100`F9d9 Println($'Cubes sum = {Algorithms.SumCubes(a,b)}')`f`b
`B100`F9d9end.`f`b
>>>Close to regular C# style
It is possible to write programs without usage of PascalABC.NET standard library. All standard .NET Framework classes and methods can be used directly.
`B100`F9d9uses System; // using .NET System namespace`f`b
`B100`F9d9begin`f`b
`B100`F9d9 var arr := Console.ReadLine.Split(`f`b
`B100`F9d9 new char[](' '),`f`b
`B100`F9d9 StringSplitOptions.RemoveEmptyEntries`f`b
`B100`F9d9 );`f`b
`B100`F9d9 var (a,b) := (integer.Parse(arr[0]),integer.Parse(arr[1]));`f`b
`B100`F9d9 var sum := 0;`f`b
`B100`F9d9 for var i:=a to b do`f`b
`B100`F9d9 sum += i*i;`f`b
`B100`F9d9 Console.WriteLine($'Sum = {sum}')`f`b
`B100`F9d9end.`f`b
>>Criticism
Though PascalABC.NET is actively used for teacher training,`:cite-ref-4-7-1[`F5bf`_`[7`#cite-note-4-7]`_`f]`:cite-ref-mathanim-10-1[`F5bf`_`[10`#cite-note-mathanim-10]`_`f]`:cite-ref-32[`F5bf`_`[32`#cite-note-32]`_`f]`:cite-ref-33[`F5bf`_`[33`#cite-note-33]`_`f] some members of the teaching community ignore difference between historically used Turbo Pascal and PascalABC.NET, criticizing some unspecified "Pascal" language for being far from modern programming, too wordy and not simple enough to be used as the first programming language.`:cite-ref-34[`F5bf`_`[34`#cite-note-34]`_`f]`:cite-ref-35[`F5bf`_`[35`#cite-note-35]`_`f] They consider Python to be the best starting point, as it is more concise and practically applicable. Their opponents, including PascalABC.NET developers themselves, argue that it is incorrect to put an equal sign between the classic Pascal and PascalABC.NET, as the latter contains lots of modern multi-paradigm features, including the ones from Python.`:cite-ref-3-8-1[`F5bf`_`[8`#cite-note-3-8]`_`f]`:cite-ref-36[`F5bf`_`[36`#cite-note-36]`_`f]`:cite-ref-37[`F5bf`_`[37`#cite-note-37]`_`f] PascalABC.NET allows students to write as concise and expressive programs as Python,`:cite-ref-38[`F5bf`_`[38`#cite-note-38]`_`f] and acts as a "bridge to production programming" by applying a static typing concept.`:cite-ref-3-8-2[`F5bf`_`[8`#cite-note-3-8]`_`f] PascalABC.NET is also a compilable language, which makes it easier to learn programming, because all semantic errors are caught at compile time rather than occur unpredictably at runtime.`:cite-ref-3-8-3[`F5bf`_`[8`#cite-note-3-8]`_`f]`:cite-ref-39[`F5bf`_`[39`#cite-note-39]`_`f] Pascal is often regarded as a strictly structured programming language, which makes it a popular choice for introductory programming education. However, some authors argue that the promotion of Python as a beginner-friendly language is driven, in part, by commercial interests.
>>References
`:cite-note-1-1`!1.`! `F0af`_`[↑`#cite-ref-1-1-0]`_`f `:citerefosipov2019`aOsipov, Alexander V. (2019). `*PascalABC.NET: Vvedenie v sovremennoe programmirovanie [PascalABC.NET: Introduction to Modern Programming]`* (in Russian). Rostov-on-Don, Russia. p. 28.`B100`F9d9{{cite book}}`f`b: CS1 maint: location missing publisher (link)
`:cite-note-2`!2.`! `F0af`_`[↑`#cite-ref-2]`_`f "Twisted Pair Podcast, #389". `*Twisted Pair Podcast`* (in Russian). 30 March 2021.
`:cite-note-3`!3.`! `F0af`_`[↑`#cite-ref-3]`_`f `:citerefbondarevbelyakovamikhalkovich2013`aBondarev, Ivan V.; Belyakova, Yulia V.; Mikhalkovich, Stanislav S. (24 April 2013). "PascalABC.NET programming system: 10 years of development" (PDF). `*PascalABC.NET`*. Retrieved 9 April 2023.
`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f "Analysis of PascalABC.NET using SonarQube plugins: SonarC# and PVS-Studio". `*PVS-Studio`*. 29 March 2017.
`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f "Re-checking PascalABC.NET". `*Medium`*. 11 February 2022.
`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f "Metodicheskie rekomendacii po podgotovke i provedeniyu edinogo gosudarstvennogo ekzamena po informatike i IKT v komp'yuternoj forme v gorode Moskve v 2021 godu [Guidelines for the preparation and conduct of the unified state exam in computer science and ICT in the city of Moscow in 2021]" (PDF) (in Russian). Departament obrazovaniya i nauki goroda Moskvy [Department of Education and Science of Moscow]. p. 110. Archived from the original (PDF) on 28 January 2022. Retrieved 5 April 2023.
`:cite-note-4-7`!7.`! `F0af`_`[↑`#cite-ref-4-7-0]`_`f `:citerefpolyakov`aPolyakov, Konstantin. "Doklady na konferenciyah i seminarah [Reports at conferences and seminars]" (in Russian).
`:cite-note-3-8`!8.`! `F0af`_`[↑`#cite-ref-3-8-0]`_`f `:citerefbogdanov2022`aBogdanov, Alexey (4 October 2022). "PascalABC.Net or Python/ C#/C++". `*YouTube`* (in Russian). Retrieved 5 April 2023.
`:cite-note-9`!9.`! `F0af`_`[↑`#cite-ref-9]`_`f `:citerefpopova2022`aPopova, Ekaterina (6 September 2022). "Kak v Rostove gumanitarii uspeshno obuchayutsya IT-special'nostyam [How humanitarians successfully study IT specialties in Rostov]". `*Komsomolskaya Pravda`* (in Russian).
`:cite-note-mathanim-10`!10.`! `F0af`_`[↑`#cite-ref-mathanim-10-0]`_`f `:citerefdzhenzherdenisova2019`aDzhenzher, V.O.; Denisova, L.V. (2019). "Mathematical animation in computer simulation at school". `*Informatics in School`* (in Russian) (6): 51–54. `F33f`_`[doi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Doi_(identifier)]`_`f:10.32517/2221-1993-2019-18-6-51-54. `F33f`_`[S2CID`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=S2CID_(identifier)]`_`f 203704481.
`:cite-note-hammingcode-11`!11.`! `F0af`_`[↑`#cite-ref-hammingcode-11-0]`_`f `:citerefdzhenzherdenisova2021`aDzhenzher, V.O.; Denisova, L.V. (2021). "Implementation of the Hamming code on PascalABC.NET while studying the theoretical foundations of informatics". `*Informatics in School`* (in Russian). `!1`! (9): 29–38. `F33f`_`[doi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Doi_(identifier)]`_`f:10.32517/2221-1993-2021-20-9-27-36. `F33f`_`[S2CID`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=S2CID_(identifier)]`_`f 245473319.
`:cite-note-scigraph-12`!12.`! `F0af`_`[↑`#cite-ref-scigraph-12-0]`_`f `:citerefdzhenzherdenisova2020`aDzhenzher, V.O.; Denisova, L.V. (2020). "Scientific graphics in PascalABC.NET: plotting function graphs in a rectangular cartesian coordinate system". `*Informatics in School`* (in Russian) (1): 31–39. `F33f`_`[doi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Doi_(identifier)]`_`f:10.32517/2221-1993-2020-19-1-31-39. `F33f`_`[S2CID`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=S2CID_(identifier)]`_`f 215844807.
`:cite-note-13`!13.`! `F0af`_`[↑`#cite-ref-13]`_`f `:citerefkulabukhov2021`aKulabukhov, S.Yu. (2021). "Mathematical modeling in informatiсs lessons using numerical solution of differential equations". `*Informatics in School`* (in Russian) (2): 14–21. `F33f`_`[doi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Doi_(identifier)]`_`f:10.32517/2221-1993-2021-20-2-14-21. `F33f`_`[S2CID`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=S2CID_(identifier)]`_`f 235541530.
`:cite-note-14`!14.`! `F0af`_`[↑`#cite-ref-14]`_`f `:citerefkhazievaivanov2020`aKhazieva, R.T.; Ivanov, M.D. (2020). "Selection of optimum device parameters for permanent magnetic field generation". `*Power Engineering: Research, Equipment, Technology`* (in Russian). `!22`! (6): 176–187. `F33f`_`[doi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Doi_(identifier)]`_`f:10.30724/1998-9903-2020-22-6-176-187. `F33f`_`[S2CID`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=S2CID_(identifier)]`_`f 233658494.
`:cite-note-15`!15.`! `F0af`_`[↑`#cite-ref-15]`_`f `:citereflukyanovzolotov2021`aLukyanov, O.E.; Zolotov, D.V. (2021). "Methodological support for the training of UAV designers and operators". `*VESTNIK of Samara University. Aerospace and Mechanical Engineering`* (in Russian). `!20`! (1): 14–28. `F33f`_`[doi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Doi_(identifier)]`_`f:10.18287/2541-7533-2021-20-1-14-28. `F33f`_`[S2CID`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=S2CID_(identifier)]`_`f 236617894.
`:cite-note-16`!16.`! `F0af`_`[↑`#cite-ref-16]`_`f "ACMP Olympiad System". Archived from the original on 27 March 2023. Retrieved 5 April 2023.
`:cite-note-17`!17.`! `F0af`_`[↑`#cite-ref-17]`_`f "Yandex Contest Compilers List". `*Yandex Contest`*. Archived from the original on 14 March 2023. Retrieved 5 April 2023.
`:cite-note-18`!18.`! `F0af`_`[↑`#cite-ref-18]`_`f `:citerefkubysheva2020`aKubysheva, Olga (17 April 2020). "PascalABC.NET: Sajt sistemy programmirovaniya, razrabatyvaemoj na mekhmate YUFU, podnyalsya v rejtinge YAndeksa na tret'e mesto [PascalABC.NET: Site of programming system developed at SFedU MMCS faculty climbed up to the third place in Yandex ranking]". `*Komsomol'skaya pravda`* (in Russian).
`:cite-note-19`!19.`! `F0af`_`[↑`#cite-ref-19]`_`f `:citerefkutysh2018`aKutysh, Aleksandr Z. (2018). "Razrabotka soderzhaniya vzaimosvyazannogo obucheniya budushchih uchitelej informatiki tekhnologiyam programmirovaniya [Development of interconnected training content for future computer science teachers in programming]" (PDF). `*Pedagogical Science and Education`* (in Russian) (3): 44–52.
`:cite-note-20`!20.`! `F0af`_`[↑`#cite-ref-20]`_`f "Practică în Pascal". `*YouTube`*. 21 January 2020.
`:cite-note-21`!21.`! `F0af`_`[↑`#cite-ref-21]`_`f "Mengenal PascalABC.NET". Archived from the original on 10 August 2022. Retrieved 8 April 2023.
`:cite-note-22`!22.`! `F0af`_`[↑`#cite-ref-22]`_`f "PASCAL AND DELPHI TUTORIAL". `*YouTube`*. 12 June 2022.
`:cite-note-2-23`!23.`! `F0af`_`[↑`#cite-ref-2-23-0]`_`f "PascalABC.NET. What's New". `*PascalABC.NET`* (in Russian). Retrieved 9 April 2023.
`:cite-note-24`!24.`! `F0af`_`[↑`#cite-ref-24]`_`f `:citerefembarcadero-technologies2018`aEmbarcadero Technologies (21 November 2018). "See What's New in RAD Studio 10.3". `*YouTube`*.
`:cite-note-25`!25.`! `F0af`_`[↑`#cite-ref-25]`_`f "Help for RAD Studio 10.3 Rio. What's New". `*Embarcadero. Product Documentation Wikis`*. Retrieved 9 April 2023.
`:cite-note-26`!26.`! `F0af`_`[↑`#cite-ref-26]`_`f `:citerefosipov2019`aOsipov, Alexander V. (2019). `*PascalABC.NET: Vvedenie v sovremennoe programmirovanie [PascalABC.NET: Introduction to Modern Programming]`* (in Russian). Rostov-on-Don, Russia. pp. 116–120.`B100`F9d9{{cite book}}`f`b: CS1 maint: location missing publisher (link)
`:cite-note-27`!27.`! `F0af`_`[↑`#cite-ref-27]`_`f `:citerefkevin-r-bond2021`aKevin R. Bond (2021). "Chapter 44. Anonymous methods". `*How to Program Effectively in Delphi for AS/A Level Computer Science`*. Educational Computing Services Ltd. `F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ISBN_(identifier)]`_`f 9780992753603.
`:cite-note-0-28`!28.`! `F0af`_`[↑`#cite-ref-0-28-0]`_`f `:citerefkevin-bond2022`aKevin Bond (10 February 2022). "How to Program Effectively in Delphi. Lesson 44. Part 1". `*YouTube`*. Retrieved 4 April 2023.
`:cite-note-29`!29.`! `F0af`_`[↑`#cite-ref-29]`_`f "Delphi Boot Camp 2022 - Delphi and functional programming using anonymous methods". `*YouTube`*. 28 August 2022. Retrieved 4 April 2023.
`:cite-note-30`!30.`! `F0af`_`[↑`#cite-ref-30]`_`f "Brief biography Dr Kevin R Bond" (PDF). `*Educational Computing Services Ltd`*. Archived from the original (PDF) on 4 April 2023. Retrieved 4 April 2023.
`:cite-note-31`!31.`! `F0af`_`[↑`#cite-ref-31]`_`f "PascalABC.NET programming styles". Retrieved 9 April 2023.
`:cite-note-32`!32.`! `F0af`_`[↑`#cite-ref-32]`_`f `:citerefdzhenzherdenisova2022`aDzhenzher, V.O.; Denisova, L.V. (2022). "Dynamic arrays and lists in PascalABC.NET". `*Informatics in School`* (in Russian) (1): 67–80. `F33f`_`[doi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Doi_(identifier)]`_`f:10.32517/2221-1993-2022-21-1-67-80. `F33f`_`[S2CID`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=S2CID_(identifier)]`_`f 249662060.
`:cite-note-33`!33.`! `F0af`_`[↑`#cite-ref-33]`_`f "Nauchno-metodicheskaya konferenciya «Ispol'zovanie sistemy programmirovaniya PascalABC.NET v obuchenii programmirovaniyu» (29-30 marta 2023 g.) [Scientific and methodical conference "Using PascalABC.NET programming system in teaching programming" (March 29-30, 2023)]". `*Institute of Mathematics, Mechanics, and Computer Science`* (in Russian). Retrieved 10 April 2023.
`:cite-note-34`!34.`! `F0af`_`[↑`#cite-ref-34]`_`f `:citerefpanovakolivnyk2020`aPanova, I.V.; Kolivnyk, A.A. (2020). "Methodological Aspects of Teaching Python Programming in the School Informatics Course". `*Informatics in School`* (in Russian) (6): 47–50. `F33f`_`[doi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Doi_(identifier)]`_`f:10.32517/2221-1993-2020-19-6-47-50. `F33f`_`[S2CID`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=S2CID_(identifier)]`_`f 225133880.
`:cite-note-35`!35.`! `F0af`_`[↑`#cite-ref-35]`_`f "What's wrong with modern computer science teaching". `*Habr`* (in Russian). 28 May 2021. Retrieved 8 April 2023.
`:cite-note-36`!36.`! `F0af`_`[↑`#cite-ref-36]`_`f `:citerefbragilevsky2020`aBragilevsky, Vitaly (14 April 2020). "The First Programming Language Dispute: The Final Solution". `*YouTube`*. JetBrains.
`:cite-note-37`!37.`! `F0af`_`[↑`#cite-ref-37]`_`f `:citerefpolyakov2021`aPolyakov, Konstantin (24 August 2021). "New features in PascalABC.NET" (in Russian).
`:cite-note-38`!38.`! `F0af`_`[↑`#cite-ref-38]`_`f `:citerefmikhalkovich2021`aMikhalkovich, Stanislav (22 November 2021). "Comparing Python and PascalABC.NET". `*YouTube`*.
`:cite-note-39`!39.`! `F0af`_`[↑`#cite-ref-39]`_`f `:citerefosipov2020`aOsipov, Alexander V. (2020). `*PascalABC.NET: vybor shkol'nika. CHast' 1. [PascalABC.NET: Schoolchildren's Choice. Part 1]`* (in Russian) (2nd ed.). Southern Federal University. pp. 16–19.
>>External links
• Official website
• PascalABC.NET on `F33f`_`[GitHub`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=GitHub]`_`f
• Official Telegram Channel `*PascalABC.NET`*
`c`F0af`_`[↑ Back to top`#top]`_`f`a